Functions in BAML define the contract between your application and AI models, providing type-safe interfaces for AI operations.

## Overview

A BAML function consists of:
- Input parameters with explicit types
- A return type specification
- An [LLM client](client-llm)
- A prompt (as a [block string](general-baml-syntax/string#block-strings))

```baml
function FunctionName(param: Type) -> ReturnType {
    client ModelName
    prompt #"
        Template content
    "#
}
```

## Function Declaration

### Syntax

```baml
function name(parameters) -> return_type {
    client llm_specification
    prompt block_string_specification
}
```

### Parameters

- `name`: The function identifier (must start with a capital letter!)
- `parameters`: One or more typed parameters (e.g., `text: string`, `data: CustomType`)
- `return_type`: The type that the function guarantees to return (e.g., `string | MyType`)
- `llm_specification`: The LLM to use (e.g., `"openai/gpt-5-mini"`, `GPT5`, `Claude4`)
- `block_string_specification`: The prompt template using Jinja syntax

## Type System

Functions leverage BAML's strong type system, supporting:

### Built-in Types
- `string`: Text data
- `int`: Integer numbers
- `float`: Decimal numbers
- `bool`: True/false values
- `array`: Denoted with `[]` suffix (e.g., `string[]`)
- `map`: Key-value pairs (e.g., `map<string, int>`)
- `literal`: Specific values (e.g., `"red" | "green" | "blue"`)
- [See all](types)

### Custom Types

Custom types can be defined using class declarations:

```baml
class CustomType {
    field1 string
    field2 int
    nested NestedType
}

function ProcessCustomType(data: CustomType) -> ResultType {
    // ...
}
```

## Prompt Templates

### Jinja Syntax

BAML uses Jinja templating for dynamic prompt generation:

```baml
prompt #"
    Input data: {{ input_data }}
    
    {% if condition %}
        Conditional content
    {% endif %}
    
    {{ ctx.output_format }}
"#
```

### Special Variables

- `ctx.output_format`: Automatically generates format instructions based on return type
- `ctx.client`: Selected client and model name
- `_.role`: Define the role of the message chunk

## Error Handling

Functions automatically handle common AI model errors and provide type validation:

- JSON parsing errors are automatically corrected
- Type mismatches are detected and reported
- Network and rate limit errors are propagated to the caller

## Usage Examples

### Basic Function

```baml
function ExtractEmail(text: string) -> string {
    client GPT4Turbo
    prompt #"
        Extract the email address from the following text:
        {{ text }}
        
        {{ ctx.output_format }}
    "#
}
```

### Complex Types

```baml
class Person {
    name string
    age int
    contacts Contact[]
}

class Contact {
    type "email" | "phone"
    value string
}

function ParsePerson(data: string) -> Person {
    client "openai/gpt-5"
    prompt #"
        {{ ctx.output_format }}
        
        {{ _.role('user') }}
        {{ data }}
    "#
}
```

## `baml_client` Integration

<CodeBlocks>

```python Python
from baml_client import b
from baml_client.types import Person

async def process() -> Person:
    result = b.ParsePerson("John Doe, 30 years old...")
    print(result.name)  # Type-safe access
    return result
```


```typescript TypeScript
import { b } from 'baml-client';
import { Person } from 'baml-client/types';

async function process(): Promise<Person> {
    const result = await b.ParsePerson("John Doe, 30 years old...");
    console.log(result.name);  // Type-safe access
    return result;
}
```

</CodeBlocks>


